package xyz.doikki.videoplayer.exo;

import androidx.annotation.Nullable;

import com.github.livebase.log.Logger;
import com.github.livebase.log.LoggerFactory;
import com.google.android.exoplayer2.ExoPlaybackException;
import com.google.android.exoplayer2.Format;
import com.google.android.exoplayer2.MediaItem;
import com.google.android.exoplayer2.PlaybackParameters;
import com.google.android.exoplayer2.Player;
import com.google.android.exoplayer2.audio.AudioAttributes;
import com.google.android.exoplayer2.decoder.DecoderCounters;
import com.google.android.exoplayer2.decoder.DecoderReuseEvaluation;
import com.google.android.exoplayer2.metadata.Metadata;
import com.google.android.exoplayer2.source.LoadEventInfo;
import com.google.android.exoplayer2.source.MediaLoadData;
import com.google.android.exoplayer2.source.TrackGroupArray;
import com.google.android.exoplayer2.trackselection.MappingTrackSelector;
import com.google.android.exoplayer2.trackselection.TrackSelectionArray;
import com.google.android.exoplayer2.util.EventLogger;
import com.google.android.exoplayer2.video.VideoSize;

import java.io.IOException;
import java.util.List;

import tv.danmaku.ijk.media.player.pragma.DebugLog;

/**
 * @ClassName IEventLogger
 * @description:
 * @author: biao532
 * @create: 2024-02-28 13:39
 * @Version 1.0
 **/
public class IEventLogger extends EventLogger {
    private static Logger logger = LoggerFactory.getLogger(DebugLog.class);
    private String TAG;
    protected IEventLogger(@Nullable MappingTrackSelector trackSelector, String tag) {
        super(trackSelector);
        this.TAG = tag;
    }

    @Override
    public void onIsLoadingChanged(EventTime eventTime, boolean isLoading) {
        if (!logger.isDebug()) {
            return;
        }
        super.onIsLoadingChanged(eventTime, isLoading);
    }

    @Override
    public void onPlaybackStateChanged(EventTime eventTime, int state) {
        if (!logger.isDebug()) {
            return;
        }
        super.onPlaybackStateChanged(eventTime, state);
    }

    @Override
    public void onPlayWhenReadyChanged(EventTime eventTime, boolean playWhenReady, int reason) {
        if (!logger.isDebug()) {
            return;
        }
        super.onPlayWhenReadyChanged(eventTime, playWhenReady, reason);
    }

    @Override
    public void onPlaybackSuppressionReasonChanged(EventTime eventTime, int playbackSuppressionReason) {
        if (!logger.isDebug()) {
            return;
        }
        super.onPlaybackSuppressionReasonChanged(eventTime, playbackSuppressionReason);
    }

    @Override
    public void onIsPlayingChanged(EventTime eventTime, boolean isPlaying) {
        if (!logger.isDebug()) {
            return;
        }
        super.onIsPlayingChanged(eventTime, isPlaying);
    }

    @Override
    public void onRepeatModeChanged(EventTime eventTime, int repeatMode) {
        if (!logger.isDebug()) {
            return;
        }
        super.onRepeatModeChanged(eventTime, repeatMode);
    }

    @Override
    public void onShuffleModeChanged(EventTime eventTime, boolean shuffleModeEnabled) {
        if (!logger.isDebug()) {
            return;
        }
        super.onShuffleModeChanged(eventTime, shuffleModeEnabled);
    }

    @Override
    public void onPositionDiscontinuity(EventTime eventTime, Player.PositionInfo oldPosition, Player.PositionInfo newPosition, int reason) {
        if (!logger.isDebug()) {
            return;
        }
        super.onPositionDiscontinuity(eventTime, oldPosition, newPosition, reason);
    }

    @Override
    public void onPlaybackParametersChanged(EventTime eventTime, PlaybackParameters playbackParameters) {
        if (!logger.isDebug()) {
            return;
        }
        super.onPlaybackParametersChanged(eventTime, playbackParameters);
    }

    @Override
    public void onTimelineChanged(EventTime eventTime, int reason) {
        if (!logger.isDebug()) {
            return;
        }
        super.onTimelineChanged(eventTime, reason);
    }

    @Override
    public void onMediaItemTransition(EventTime eventTime, @Nullable MediaItem mediaItem, int reason) {
        if (!logger.isDebug()) {
            return;
        }
        super.onMediaItemTransition(eventTime, mediaItem, reason);
    }

    @Override
    public void onPlayerError(EventTime eventTime, ExoPlaybackException e) {
        if (logger.isError()) {
            super.onPlayerError(eventTime, e);
        }
    }

    @Override
    public void onTracksChanged(EventTime eventTime, TrackGroupArray ignored, TrackSelectionArray trackSelections) {
        if (!logger.isDebug()) {
            return;
        }
        super.onTracksChanged(eventTime, ignored, trackSelections);
    }

    @Override
    public void onStaticMetadataChanged(EventTime eventTime, List<Metadata> metadataList) {
        if (!logger.isDebug()) {
            return;
        }
        super.onStaticMetadataChanged(eventTime, metadataList);
    }

    @Override
    public void onMetadata(EventTime eventTime, Metadata metadata) {
        if (!logger.isDebug()) {
            return;
        }
        super.onMetadata(eventTime, metadata);
    }

    @Override
    public void onAudioEnabled(EventTime eventTime, DecoderCounters counters) {
        if (!logger.isDebug()) {
            return;
        }
        super.onAudioEnabled(eventTime, counters);
    }

    @Override
    public void onAudioDecoderInitialized(EventTime eventTime, String decoderName, long initializationDurationMs) {
        if (!logger.isDebug()) {
            return;
        }
        super.onAudioDecoderInitialized(eventTime, decoderName, initializationDurationMs);
    }

    @Override
    public void onAudioInputFormatChanged(EventTime eventTime, Format format, @Nullable DecoderReuseEvaluation decoderReuseEvaluation) {
        if (!logger.isDebug()) {
            return;
        }
        super.onAudioInputFormatChanged(eventTime, format, decoderReuseEvaluation);
    }

    @Override
    public void onAudioUnderrun(EventTime eventTime, int bufferSize, long bufferSizeMs, long elapsedSinceLastFeedMs) {
        if (logger.isError()) {
            super.onAudioUnderrun(eventTime, bufferSize, bufferSizeMs, elapsedSinceLastFeedMs);
        }
    }

    @Override
    public void onAudioDecoderReleased(EventTime eventTime, String decoderName) {
        if (!logger.isDebug()) {
            return;
        }
        super.onAudioDecoderReleased(eventTime, decoderName);
    }

    @Override
    public void onAudioDisabled(EventTime eventTime, DecoderCounters counters) {
        if (!logger.isDebug()) {
            return;
        }
        super.onAudioDisabled(eventTime, counters);
    }

    @Override
    public void onAudioSessionIdChanged(EventTime eventTime, int audioSessionId) {
        if (!logger.isDebug()) {
            return;
        }
        super.onAudioSessionIdChanged(eventTime, audioSessionId);
    }

    @Override
    public void onAudioAttributesChanged(EventTime eventTime, AudioAttributes audioAttributes) {
        if (!logger.isDebug()) {
            return;
        }
        super.onAudioAttributesChanged(eventTime, audioAttributes);
    }

    @Override
    public void onSkipSilenceEnabledChanged(EventTime eventTime, boolean skipSilenceEnabled) {
        if (!logger.isDebug()) {
            return;
        }
        super.onSkipSilenceEnabledChanged(eventTime, skipSilenceEnabled);
    }

    @Override
    public void onVolumeChanged(EventTime eventTime, float volume) {
        if (!logger.isDebug()) {
            return;
        }
        super.onVolumeChanged(eventTime, volume);
    }

    @Override
    public void onVideoEnabled(EventTime eventTime, DecoderCounters counters) {
        if (!logger.isDebug()) {
            return;
        }
        super.onVideoEnabled(eventTime, counters);
    }

    @Override
    public void onVideoDecoderInitialized(EventTime eventTime, String decoderName, long initializationDurationMs) {
        if (!logger.isDebug()) {
            return;
        }
        super.onVideoDecoderInitialized(eventTime, decoderName, initializationDurationMs);
    }

    @Override
    public void onVideoInputFormatChanged(EventTime eventTime, Format format, @Nullable DecoderReuseEvaluation decoderReuseEvaluation) {
        if (!logger.isDebug()) {
            return;
        }
        super.onVideoInputFormatChanged(eventTime, format, decoderReuseEvaluation);
    }

    @Override
    public void onDroppedVideoFrames(EventTime eventTime, int count, long elapsedMs) {
        if (!logger.isDebug()) {
            return;
        }
        super.onDroppedVideoFrames(eventTime, count, elapsedMs);
    }

    @Override
    public void onVideoDecoderReleased(EventTime eventTime, String decoderName) {
        if (!logger.isDebug()) {
            return;
        }
        super.onVideoDecoderReleased(eventTime, decoderName);
    }

    @Override
    public void onVideoDisabled(EventTime eventTime, DecoderCounters counters) {
        if (!logger.isDebug()) {
            return;
        }
        super.onVideoDisabled(eventTime, counters);
    }

    @Override
    public void onRenderedFirstFrame(EventTime eventTime, Object output, long renderTimeMs) {
        if (!logger.isDebug()) {
            return;
        }
        super.onRenderedFirstFrame(eventTime, output, renderTimeMs);
    }

    @Override
    public void onVideoSizeChanged(EventTime eventTime, VideoSize videoSize) {
        if (!logger.isDebug()) {
            return;
        }
        super.onVideoSizeChanged(eventTime, videoSize);
    }

    @Override
    public void onLoadStarted(EventTime eventTime, LoadEventInfo loadEventInfo, MediaLoadData mediaLoadData) {
        if (!logger.isDebug()) {
            return;
        }
        super.onLoadStarted(eventTime, loadEventInfo, mediaLoadData);
    }

    @Override
    public void onLoadError(EventTime eventTime, LoadEventInfo loadEventInfo, MediaLoadData mediaLoadData, IOException error, boolean wasCanceled) {
        if (!logger.isDebug()) {
            return;
        }
        super.onLoadError(eventTime, loadEventInfo, mediaLoadData, error, wasCanceled);
    }

    @Override
    public void onLoadCanceled(EventTime eventTime, LoadEventInfo loadEventInfo, MediaLoadData mediaLoadData) {
        if (!logger.isDebug()) {
            return;
        }
        super.onLoadCanceled(eventTime, loadEventInfo, mediaLoadData);
    }

    @Override
    public void onLoadCompleted(EventTime eventTime, LoadEventInfo loadEventInfo, MediaLoadData mediaLoadData) {
        if (!logger.isDebug()) {
            return;
        }
        super.onLoadCompleted(eventTime, loadEventInfo, mediaLoadData);
    }

    @Override
    public void onBandwidthEstimate(EventTime eventTime, int totalLoadTimeMs, long totalBytesLoaded, long bitrateEstimate) {
        if (!logger.isDebug()) {
            return;
        }
        super.onBandwidthEstimate(eventTime, totalLoadTimeMs, totalBytesLoaded, bitrateEstimate);
    }

    @Override
    public void onSurfaceSizeChanged(EventTime eventTime, int width, int height) {
        if (!logger.isDebug()) {
            return;
        }
        super.onSurfaceSizeChanged(eventTime, width, height);
    }

    @Override
    public void onUpstreamDiscarded(EventTime eventTime, MediaLoadData mediaLoadData) {
        if (!logger.isDebug()) {
            return;
        }
        super.onUpstreamDiscarded(eventTime, mediaLoadData);
    }

    @Override
    public void onDownstreamFormatChanged(EventTime eventTime, MediaLoadData mediaLoadData) {
        if (!logger.isDebug()) {
            return;
        }
        super.onDownstreamFormatChanged(eventTime, mediaLoadData);
    }

    @Override
    public void onDrmSessionAcquired(EventTime eventTime, int state) {
        if (!logger.isDebug()) {
            return;
        }
        super.onDrmSessionAcquired(eventTime, state);
    }

    @Override
    public void onDrmSessionManagerError(EventTime eventTime, Exception e) {
        if (!logger.isDebug()) {
            return;
        }
        super.onDrmSessionManagerError(eventTime, e);
    }

    @Override
    public void onDrmKeysRestored(EventTime eventTime) {
        if (!logger.isDebug()) {
            return;
        }
        super.onDrmKeysRestored(eventTime);
    }

    @Override
    public void onDrmKeysRemoved(EventTime eventTime) {
        if (!logger.isDebug()) {
            return;
        }
        super.onDrmKeysRemoved(eventTime);
    }

    @Override
    public void onDrmKeysLoaded(EventTime eventTime) {
        if (!logger.isDebug()) {
            return;
        }
        super.onDrmKeysLoaded(eventTime);
    }

    @Override
    public void onDrmSessionReleased(EventTime eventTime) {
        if (!logger.isDebug()) {
            return;
        }
        super.onDrmSessionReleased(eventTime);
    }

    @Override
    protected void logd(String msg) {
        logger.debug(TAG, msg);
    }

    @Override
    protected void loge(String msg) {
        logger.error(TAG, msg);
    }
}
